/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.evangelion.core.controller;

import com.evangelion.core.bean.Alumno;
import com.evangelion.core.bean.Examen;
import com.evangelion.core.bean.Profesor;
import com.evangelion.core.bean.Seccione;
import com.evangelion.core.bean.Usuario;
import com.evangelion.core.service.AlumnoService;
import com.evangelion.core.service.ExamenService;
import com.evangelion.core.service.FacturaAlumnoService;
import com.evangelion.core.service.ProfesorService;
import com.evangelion.core.serviceImpl.AlumnoServiceImpl;
import com.evangelion.core.serviceImpl.ExamenServiceImpl;
import com.evangelion.core.serviceImpl.FacturaAlumnoServiceImpl;
import com.evangelion.core.serviceImpl.ProfesorServiceImpl;
import com.evangelion.core.utils.ExamenConverter;
import com.evangelion.core.utils.MensajesFace;
import com.evangelion.core.utils.ProveedorConverter;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.PostConstruct;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.primefaces.context.RequestContext;
import org.primefaces.model.LazyDataModel;
import org.primefaces.model.SortOrder;
import org.primefaces.model.chart.CartesianChartModel;
import org.primefaces.model.chart.ChartSeries;

/**
 *
 * @author Usuario
 */
@ManagedBean
@ViewScoped
public class DgtController extends MensajesFace implements Serializable {

    Examen examen;
    Examen examenResultado;
    ExamenService examenService = new ExamenServiceImpl();
    List<Examen> examenList;
    Date fechadesde;
    Date fechahasta;
    Date fechadesdeGrafic;
    Date fechahastaGrafic;
    Seccione seccion;
    Usuario usuario;
    private LazyDataModel<Alumno> listAlumno;
    AlumnoService serviceAlunmo = new AlumnoServiceImpl();
    ProfesorService serviceProfesor = new ProfesorServiceImpl();
    FacturaAlumnoService facturaAlumn = new FacturaAlumnoServiceImpl();
    String searchParamAlumno;
    String searchParamAlumno2;
    String searchParamAlumno3;
    String valor;
    boolean renderTable;
    List<Examen> examenList2;
    List<Examen> examenresultadoList;
    List<Examen> examenResPresentado;
    Date fechadesde2;
    Date fechahasta2;
    Examen examen2;
    String tipoprueba;
    String searchParamProfesor;
    private LazyDataModel<Profesor> listProfesor;
    boolean renderTableProfesor;
    CartesianChartModel graficMatriculaMensual;
    CartesianChartModel graficMatMensualPermiso;
    CartesianChartModel graficResMensual;

    @PostConstruct
    public void init() {
        FacesContext context = FacesContext.getCurrentInstance();
        HttpServletRequest request = (HttpServletRequest) context.getExternalContext().getRequest();
        HttpSession httpSession = request.getSession(false);
        if (httpSession != null) {
            usuario = (Usuario) httpSession.getAttribute("UserSession");
            seccion = (Seccione) httpSession.getAttribute("seccion");
        }
        examen = new Examen();
        examenList = new ArrayList<Examen>();
        examenResPresentado = new ArrayList<Examen>();
        examen2 = new Examen();
        examenList2 = new ArrayList<Examen>();
        examenResultado = new Examen();
        examenresultadoList = new ExamenConverter(new ArrayList<Examen>()).linkTypesDB;
        searchParamAlumno3 = "";
        searchParamProfesor = "";
        graficMatriculaMensual = new CartesianChartModel();
        graficMatMensualPermiso = new CartesianChartModel();
        graficResMensual = new CartesianChartModel();
//        examenList=examenService.findByParam("permiso", "");

    }

    public void save(String prueba) {
        if (prueba.equals("Resultado")) {
            examenResultado.setClienteregexamen(usuario.getCliente());
            examenResultado.setFechaingexamen(new Date());
            examenResultado.setEstadoexamen("Presentado");
            examenService.save(examenResultado);
            if (examenResultado.getFechaproxexamen() != null) {
                Examen exa = new Examen();
                exa.setAlumno(examenResultado.getAlumno());
                exa.setCliente(examenResultado.getCliente());
                exa.setConvocatoria(examenResultado.getConvocatoria());
                exa.setEstado("Repetidor");
                exa.setEstadoexamen("Activo");
                exa.setFallo(examenResultado.getFallo());
                exa.setFechaexamen(examenResultado.getFechaproxexamen());
                exa.setPermiso(examenResultado.getPermiso());
                exa.setPrueba(examenResultado.getPrueba());
                exa.setSeccion(examenResultado.getSeccion());
                exa.setSolicitud(examenResultado.getSolicitud());
                examenService.save(exa);
            }
//            examenresultadoList = new ExamenConverter(examenService.findByAlumnoEstado(seccion, examenResultado.getAlumno(), "Activo")).linkTypesDB;
//            
//            examenResPresentado = examenService.findByAlumnoEstado(seccion, examenResultado.getAlumno(), "Presentado");

        } else {
            if (prueba.equals("Practico")) {
                examen = examen2;
            } else {
                examen.setPrueba(prueba);
            }
            examen.setEstadoexamen("Activo");

            examen.setCliente(usuario.getCliente());
            examen.setSeccion(seccion);
            examenService.save(examen);

        }
        init();
        msgCambiosGuardados();

    }

    public void selecExamen(Alumno alumno, String tipo) {
        examen.setAlumno(alumno);
        if (tipo.equals("Teorico")) {
            searchParamAlumno = alumno.getNombres() + " " + alumno.getApellidos();
            RequestContext.getCurrentInstance().update(":formgdt:tabViewgdt:idalumno");
        } else {
            searchParamAlumno2 = alumno.getNombres() + " " + alumno.getApellidos();
            RequestContext.getCurrentInstance().update(":formgdt:tabViewgdt:idalumno2");
        }
    }

    public void onRowSelectAlumno(Alumno alumno) {
        renderTable = false;

        if (tipoprueba.equals("Teorico")) {
            examen.setAlumno(alumno);
            searchParamAlumno = alumno.getNombres() + " " + alumno.getApellidos();
            RequestContext.getCurrentInstance().update(":formgdt:tabViewgdt:idalumno");
        }
        if (tipoprueba.equals("Practico")) {
            examen2.setAlumno(alumno);
            searchParamAlumno2 = alumno.getNombres() + " " + alumno.getApellidos();
            RequestContext.getCurrentInstance().update(":formgdt:tabViewgdt:idalumno2");
        }
        if (tipoprueba.equals("Resultado")) {
            examenresultadoList = new ExamenConverter(examenService.findByAlumnoEstado(seccion, alumno, "Activo")).linkTypesDB;
            if (examenresultadoList.isEmpty()) {
                msgAdvertencia("Este alumno no posee examenes pendientes por realizar");
            }
            examenResPresentado = examenService.findByAlumnoEstado(seccion, alumno, "Presentado");
            searchParamAlumno3 = alumno.getNombres() + " " + alumno.getApellidos();
            RequestContext.getCurrentInstance().update(":formgdt:tabViewgdt:idalumnoresultado");
        }
    }

    public void buscarListaAlumno(String tipoprueba) {
        this.tipoprueba = tipoprueba;
        if (tipoprueba.equals("Teorico")) {
            valor = searchParamAlumno;
            configDataModelFacAlum();
        }
        if (tipoprueba.equals("Practico")) {
            valor = searchParamAlumno2;
            configDataModelFacAlum();
        }
        if (tipoprueba.equals("Resultado")) {
            valor = searchParamAlumno3;
            configDataModelFacAlum();
        }

        renderTable = true;
    }

    @SuppressWarnings("serial")
    public void configDataModelFacAlum() {
        listAlumno = new LazyDataModel<Alumno>() {
            @Override
            public List<Alumno> load(int start, int max, String arg2,
                    SortOrder arg3, Map<String, String> arg4) {
                if (valor == null) {
                    valor = "";
                }
                return serviceAlunmo.searchByNifNombre(seccion, valor, start, max);

            }
        };
        listAlumno.setRowCount(serviceAlunmo.countPage(seccion, valor));
    }

    public void onRowSelectProfesor(Profesor profes) {
        renderTableProfesor = false;
        examenResultado.setProfesor(profes);
        searchParamProfesor = examenResultado.getProfesor().getNombres() + " " + examenResultado.getProfesor().getApellidos();
//        RequestContext.getCurrentInstance().execute("updateProfParam()");
    }

    public void buscarListaProfesor() {
        configDataModel();
        renderTableProfesor = true;
    }

    @SuppressWarnings("serial")
    public void configDataModel() {
        listProfesor = new LazyDataModel<Profesor>() {
            @Override
            public List<Profesor> load(int start, int max, String arg2,
                    SortOrder arg3, Map<String, String> arg4) {
                if (searchParamProfesor == null) {
                    searchParamProfesor = "";
                }
                return (List) serviceProfesor.searchByNifNombre(seccion, searchParamProfesor, start, max);
            }
        };
        listProfesor.setRowCount(serviceProfesor.countPage(seccion, searchParamProfesor));
    }

    public void buscarListaExamen(String prueba) {
        if (prueba.equals("Teorico")) {
            examenList = examenService.findByRangeDate(seccion, fechadesde, fechahasta, prueba);
        } else {
            examenList2 = examenService.findByRangeDate(seccion, fechadesde2, fechahasta2, prueba);
            System.out.println("examenList2:" + examenList2);
        }
    }

    public void matriculaGrafic() {

        List<Object[]> matriculaMensual = facturaAlumn.matriculasMensuales(seccion, fechadesdeGrafic, fechahastaGrafic);
        graficMatriculaMensual = new CartesianChartModel();

        ChartSeries mat = new ChartSeries();
        mat.setLabel("Matricula");
        for (int i = 0; i < matriculaMensual.size(); i++) {
            mat.set(matriculaMensual.get(i)[1].toString(), (Long) matriculaMensual.get(i)[0]);
        }
        graficMatriculaMensual.addSeries(mat);
        //--------------------------
        graficMatMensualPermiso = new CartesianChartModel();
        List<Object[]> matriculaMenPerm = facturaAlumn.matriculasMensualesPermiso(seccion, fechadesdeGrafic, fechahastaGrafic, null);
        String valorPermiso = "";
        HashMap<String, List<Object[]>> map = new HashMap<String, List<Object[]>>();
        HashMap<String, String> keys = new HashMap<String, String>();
        for (int i = 0; i < matriculaMenPerm.size(); i++) {
            List<Object[]> lista = new ArrayList<Object[]>();
            if (map.containsKey(matriculaMenPerm.get(i)[2] + "")) {
                lista = map.get(matriculaMenPerm.get(i)[2] + "");
            }
            keys.put(matriculaMenPerm.get(i)[1] + "", matriculaMenPerm.get(i)[1] + "");
            lista.add(matriculaMenPerm.get(i));
            map.put(matriculaMenPerm.get(i)[2] + "", lista);
        }
        for (Map.Entry<String, List<Object[]>> entry : map.entrySet()) {
            String string = entry.getKey();
            HashMap<String, String> mapCompare = new HashMap<String, String>();
            mat = new ChartSeries();
            for (Object[] objects : entry.getValue()) {
                if (!string.equals(valorPermiso)) {
//                    if (!valorPermiso.equals("")) {
//                        graficMatMensualPermiso.addSeries(mat);
//                    }
                    valorPermiso = string;
                    mat.setLabel(string);
                }
                mapCompare.put(objects[1].toString(), objects[2].toString());
                mat.set(objects[1].toString(), (Long) objects[0]);
            }
            for (Map.Entry<String, String> key : keys.entrySet()) {
                if (!mapCompare.containsKey(key.getKey())) {
                    mat.set(key.getValue(), 0);
                }
            }
            graficMatMensualPermiso.addSeries(mat);
        }

        ResultadosGrafic();

    }

    public void ResultadosGrafic() {

        List<Object[]> resultadoMensual = examenService.examenResultadoMensual(seccion, fechadesdeGrafic, fechahastaGrafic);
        graficResMensual = new CartesianChartModel();
        String valorPermiso = "";
        HashMap<String, List<Object[]>> map = new HashMap<String, List<Object[]>>();
        HashMap<String, String> keys = new HashMap<String, String>();
        for (int i = 0; i < resultadoMensual.size(); i++) {
            List<Object[]> lista = new ArrayList<Object[]>();
            if (map.containsKey(resultadoMensual.get(i)[2] + "")) {
                lista = map.get(resultadoMensual.get(i)[2] + "");
            }
            lista.add(resultadoMensual.get(i));
            keys.put(resultadoMensual.get(i)[1] + "", resultadoMensual.get(i)[1] + "");
            map.put(resultadoMensual.get(i)[2] + "", lista);
            System.out.println("......................................" + resultadoMensual.get(i)[0] + ".." + resultadoMensual.get(i)[1] + "-" + resultadoMensual.get(i)[2]);
        }
        ChartSeries mat;
        for (Map.Entry<String, List<Object[]>> entry : map.entrySet()) {
            String string = entry.getKey();
            mat = new ChartSeries();
            HashMap<String, String> mapCompare = new HashMap<String, String>();
            for (Object[] objects : entry.getValue()) {

                if (!string.equals(valorPermiso)) {
                    valorPermiso = string;
                    mat.setLabel(string);
                    System.out.println("Etiqueta" + string);
                }
                mapCompare.put(objects[1].toString(), objects[2].toString());
                System.out.println("objects[1].toString(), (Long) objects[0]...." + objects[1].toString() + "-" + (Long) objects[0]);
                mat.set(objects[1].toString(), (Long) objects[0]);
            }
            for (Map.Entry<String, String> key : keys.entrySet()) {
                if (!mapCompare.containsKey(key.getKey())) {
                    mat.set(key.getValue(), 0);
                }
            }
            graficResMensual.addSeries(mat);
        }


    }

    public Examen getExamen() {
        return examen;
    }

    public void setExamen(Examen examen) {
        this.examen = examen;
    }

    public ExamenService getExamenService() {
        return examenService;
    }

    public void setExamenService(ExamenService examenService) {
        this.examenService = examenService;
    }

    public List<Examen> getExamenList() {
        return examenList;
    }

    public void setExamenList(List<Examen> examenList) {
        this.examenList = examenList;
    }

    public Date getFechadesde() {
        return fechadesde;
    }

    public void setFechadesde(Date fechadesde) {
        this.fechadesde = fechadesde;
    }

    public Date getFechahasta() {
        return fechahasta;
    }

    public void setFechahasta(Date fechahasta) {
        this.fechahasta = fechahasta;
    }

    public LazyDataModel<Alumno> getListAlumno() {
        return listAlumno;
    }

    public void setListAlumno(LazyDataModel<Alumno> listAlumno) {
        this.listAlumno = listAlumno;
    }

    public String getSearchParamAlumno() {
        return searchParamAlumno;
    }

    public void setSearchParamAlumno(String searchParamAlumno) {
        this.searchParamAlumno = searchParamAlumno;
    }

    public boolean isRenderTable() {
        return renderTable;
    }

    public void setRenderTable(boolean renderTable) {
        this.renderTable = renderTable;
    }

    public List<Examen> getExamenList2() {
        return examenList2;
    }

    public void setExamenList2(List<Examen> examenList2) {
        this.examenList2 = examenList2;
    }

    public Date getFechadesde2() {
        return fechadesde2;
    }

    public void setFechadesde2(Date fechadesde2) {
        this.fechadesde2 = fechadesde2;
    }

    public Date getFechahasta2() {
        return fechahasta2;
    }

    public void setFechahasta2(Date fechahasta2) {
        this.fechahasta2 = fechahasta2;
    }

    public Examen getExamen2() {
        return examen2;
    }

    public void setExamen2(Examen examen2) {
        this.examen2 = examen2;
    }

    public String getSearchParamAlumno2() {
        return searchParamAlumno2;
    }

    public void setSearchParamAlumno2(String searchParamAlumno2) {
        this.searchParamAlumno2 = searchParamAlumno2;
    }

    public String getSearchParamAlumno3() {
        return searchParamAlumno3;
    }

    public void setSearchParamAlumno3(String searchParamAlumno3) {
        this.searchParamAlumno3 = searchParamAlumno3;
    }

    public List<Examen> getExamenresultadoList() {
        return examenresultadoList;
    }

    public void setExamenresultadoList(List<Examen> examenresultadoList) {
        this.examenresultadoList = examenresultadoList;
    }

    public Examen getExamenResultado() {
        return examenResultado;
    }

    public void setExamenResultado(Examen examenResultado) {
        this.examenResultado = examenResultado;
    }

    public String getSearchParamProfesor() {
        return searchParamProfesor;
    }

    public void setSearchParamProfesor(String searchParamProfesor) {
        this.searchParamProfesor = searchParamProfesor;
    }

    public boolean isRenderTableProfesor() {
        return renderTableProfesor;
    }

    public void setRenderTableProfesor(boolean renderTableProfesor) {
        this.renderTableProfesor = renderTableProfesor;
    }

    public LazyDataModel<Profesor> getListProfesor() {
        return listProfesor;
    }

    public void setListProfesor(LazyDataModel<Profesor> listProfesor) {
        this.listProfesor = listProfesor;
    }

    public List<Examen> getExamenResPresentado() {
        return examenResPresentado;
    }

    public void setExamenResPresentado(List<Examen> examenResPresentado) {
        this.examenResPresentado = examenResPresentado;
    }

    public Date getFechadesdeGrafic() {
        return fechadesdeGrafic;
    }

    public void setFechadesdeGrafic(Date fechadesdeGrafic) {
        this.fechadesdeGrafic = fechadesdeGrafic;
    }

    public Date getFechahastaGrafic() {
        return fechahastaGrafic;
    }

    public void setFechahastaGrafic(Date fechahastaGrafic) {
        this.fechahastaGrafic = fechahastaGrafic;
    }

    public CartesianChartModel getGraficMatriculaMensual() {
        return graficMatriculaMensual;
    }

    public void setGraficMatriculaMensual(CartesianChartModel graficMatriculaMensual) {
        this.graficMatriculaMensual = graficMatriculaMensual;
    }

    public CartesianChartModel getGraficMatMensualPermiso() {
        return graficMatMensualPermiso;
    }

    public void setGraficMatMensualPermiso(CartesianChartModel graficMatMensualPermiso) {
        this.graficMatMensualPermiso = graficMatMensualPermiso;
    }

    public CartesianChartModel getGraficResMensual() {
        return graficResMensual;
    }

    public void setGraficResMensual(CartesianChartModel graficResMensual) {
        this.graficResMensual = graficResMensual;
    }
}
